// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stddef.h>

#include "base/logging.h"
#include "cc/resources/resource_util.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace cc {
namespace {

    struct TestFormat {
        ResourceFormat format;
        size_t expected_bytes;
        size_t expected_bytes_aligned;
    };

    // Modify this constant as per TestFormat variables defined in following tests.
    const int kTestFormats = 4;

    class ResourceUtilTest : public testing::Test {
    public:
        void TestVerifyWidthInBytes(int width, const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                EXPECT_TRUE(ResourceUtil::VerifyWidthInBytes<size_t>(
                    width, test_formats[i].format));
            }
        }

        void TestCheckedWidthInBytes(int width, const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                size_t bytes = ResourceUtil::CheckedWidthInBytes<size_t>(
                    width, test_formats[i].format);
                EXPECT_EQ(bytes, test_formats[i].expected_bytes);
            }
        }

        void TestUncheckedWidthInBytes(int width, const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                size_t bytes = ResourceUtil::UncheckedWidthInBytes<size_t>(
                    width, test_formats[i].format);
                EXPECT_EQ(bytes, test_formats[i].expected_bytes);
            }
        }

        void TestUncheckedWidthInBytesAligned(int width,
            const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                size_t bytes = ResourceUtil::UncheckedWidthInBytesAligned<size_t>(
                    width, test_formats[i].format);
                EXPECT_EQ(bytes, test_formats[i].expected_bytes_aligned);
            }
        }

        void TestVerifySizeInBytes(const gfx::Size& size,
            const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                EXPECT_TRUE(ResourceUtil::VerifySizeInBytes<size_t>(
                    size, test_formats[i].format));
            }
        }

        void TestCheckedSizeInBytes(const gfx::Size& size,
            const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                size_t bytes = ResourceUtil::CheckedSizeInBytes<size_t>(
                    size, test_formats[i].format);
                EXPECT_EQ(bytes, test_formats[i].expected_bytes);
            }
        }

        void TestUncheckedSizeInBytes(const gfx::Size& size,
            const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                size_t bytes = ResourceUtil::UncheckedSizeInBytes<size_t>(
                    size, test_formats[i].format);
                EXPECT_EQ(bytes, test_formats[i].expected_bytes);
            }
        }

        void TestUncheckedSizeInBytesAligned(const gfx::Size& size,
            const TestFormat* test_formats)
        {
            for (int i = 0; i < kTestFormats; ++i) {
                size_t bytes = ResourceUtil::UncheckedSizeInBytesAligned<size_t>(
                    size, test_formats[i].format);
                EXPECT_EQ(bytes, test_formats[i].expected_bytes_aligned);
            }
        }
    };

    TEST_F(ResourceUtilTest, WidthInBytes)
    {
        // Check bytes for even width.
        int width = 10;
        TestFormat test_formats[] = {
            { RGBA_8888, 40, 40 }, // for 32 bits
            { RGBA_4444, 20, 20 }, // for 16 bits
            { ALPHA_8, 10, 12 }, // for 8 bits
            { ETC1, 5, 8 } // for 4 bits
        };

        TestVerifyWidthInBytes(width, test_formats);
        TestCheckedWidthInBytes(width, test_formats);
        TestUncheckedWidthInBytes(width, test_formats);
        TestUncheckedWidthInBytesAligned(width, test_formats);

        // Check bytes for odd width.
        int width_odd = 11;
        TestFormat test_formats_odd[] = {
            { RGBA_8888, 44, 44 }, // for 32 bits
            { RGBA_4444, 22, 24 }, // for 16 bits
            { ALPHA_8, 11, 12 }, // for 8 bits
            { ETC1, 6, 8 } // for 4 bits
        };

        TestVerifyWidthInBytes(width_odd, test_formats_odd);
        TestCheckedWidthInBytes(width_odd, test_formats_odd);
        TestUncheckedWidthInBytes(width_odd, test_formats_odd);
        TestUncheckedWidthInBytesAligned(width_odd, test_formats_odd);
    }

    TEST_F(ResourceUtilTest, SizeInBytes)
    {
        // Check bytes for even size.
        gfx::Size size(10, 10);
        TestFormat test_formats[] = {
            { RGBA_8888, 400, 400 }, // for 32 bits
            { RGBA_4444, 200, 200 }, // for 16 bits
            { ALPHA_8, 100, 120 }, // for 8 bits
            { ETC1, 50, 80 } // for 4 bits
        };

        TestVerifySizeInBytes(size, test_formats);
        TestCheckedSizeInBytes(size, test_formats);
        TestUncheckedSizeInBytes(size, test_formats);
        TestUncheckedSizeInBytesAligned(size, test_formats);

        // Check bytes for odd size.
        gfx::Size size_odd(11, 11);
        TestFormat test_formats_odd[] = {
            { RGBA_8888, 484, 484 }, // for 32 bits
            { RGBA_4444, 242, 264 }, // for 16 bits
            { ALPHA_8, 121, 132 }, // for 8 bits
            { ETC1, 66, 88 } // for 4 bits
        };

        TestVerifySizeInBytes(size_odd, test_formats_odd);
        TestCheckedSizeInBytes(size_odd, test_formats_odd);
        TestUncheckedSizeInBytes(size_odd, test_formats_odd);
        TestUncheckedSizeInBytesAligned(size_odd, test_formats_odd);
    }

    TEST_F(ResourceUtilTest, WidthInBytesOverflow)
    {
        int width = 10;
        // 10 * 16 = 160 bits, overflows in char, but fits in unsigned char.
        EXPECT_FALSE(ResourceUtil::VerifyWidthInBytes<signed char>(width, RGBA_4444));
        EXPECT_TRUE(
            ResourceUtil::VerifyWidthInBytes<unsigned char>(width, RGBA_4444));
    }

    TEST_F(ResourceUtilTest, SizeInBytesOverflow)
    {
        gfx::Size size(10, 10);
        // 10 * 16 * 10 = 1600 bits, overflows in char, but fits in int.
        EXPECT_FALSE(ResourceUtil::VerifySizeInBytes<signed char>(size, RGBA_4444));
        EXPECT_TRUE(ResourceUtil::VerifySizeInBytes<int>(size, RGBA_4444));
    }

} // namespace
} // namespace cc
